[AWS IoT Core Device Location] 今、何処で動作しているのかをデバイスに聞いてみた

import time
import json
import subprocess
from mqtt import Mqtt

response = None


def getWifi():
    cmd = "sudo iwlist wlan0 scan"
    res = subprocess.run(
        cmd.split(" "),
        capture_output=True,
        text=True,
    )
    lines = res.stdout.split("\n")
    addressList = []
    signalList = []
    for i, line in enumerate(lines):
        if "Address:" in line:
            # Cell 01 - Address: xx:xx:xx:xx:xx:xx
            tmp = line.split("Address:")
            addressList.append(tmp[1].strip(" "))
        if "Signal" in line:
            # Quality=26/70  Signal level=-84 dBm
            tmp = line.split("level=")
            #  -84 dBm
            tmp = tmp[1].split("dBm")
            signalList.append(tmp[0].strip(" "))

    timestamp = time.time()
    response = {"Timestamp": timestamp, "WiFiAccessPoints": []}
    for i, address in enumerate(addressList):
        response["WiFiAccessPoints"].append(
            {"MacAddress": address, "Rss": int(signalList[i])}
        )
    return response


def on_receive(publish_packet_data):
    publish_packet = publish_packet_data.publish_packet
    command = publish_packet.payload.decode()
    print("Received the command [{}]".format(command))
    if command == "location":
        global response
        response = getWifi()


if __name__ == "__main__":
    endpoint = "xxxxxxxxxxxx-ats.iot.ap-northeast-1.amazonaws.com"
    port = 8883

    client_id = "0001"
    subscribe_topic = "command/{}".format(client_id)
    publish_topic = "sensor/{}".format(client_id)

    mqtt = Mqtt(endpoint, port, client_id, subscribe_topic, on_receive)
    while True:
        if response != None:
            print("Send a response")
            mqtt.publish(publish_topic, json.dumps(response))
            response = None
        time.sleep(1)
    # Disconnect
    mqtt.stop()

import os
from concurrent.futures import Future
from awsiot import mqtt5_client_builder
from awscrt import mqtt5


class Mqtt:
    future_connection_success = Future()

    def __init__(self, endpoint, port, client_id, subscribe_topic, on_recv):
        dir = os.path.dirname(os.path.abspath(__file__))
        certs = {
            "cafile": "{}/certs/AmazonRootCA1.pem".format(dir),
            "certfile": "{}/certs/client-cert.pem".format(dir),
            "keyfile": "{}/certs/private-key.pem".format(dir),
        }
        self.TIMEOUT = 100

        self.client = mqtt5_client_builder.mtls_from_path(
            endpoint=endpoint,
            port=port,
            cert_filepath=certs["certfile"],
            pri_key_filepath=certs["keyfile"],
            ca_filepath=certs["cafile"],
            on_publish_received=on_recv,
            on_lifecycle_connection_success=self.on_lifecycle_connection_success,
            client_id=client_id,
        )

        self.client.start()
        lifecycle_connect_success_data = self.future_connection_success.result(
            self.TIMEOUT
        )
        connack_packet = lifecycle_connect_success_data.connack_packet
        negotiated_settings = lifecycle_connect_success_data.negotiated_settings

        # Subscribe
        subscribe_future = self.client.subscribe(
            subscribe_packet=mqtt5.SubscribePacket(
                subscriptions=[
                    mqtt5.Subscription(
                        topic_filter=subscribe_topic, qos=mqtt5.QoS.AT_LEAST_ONCE
                    )
                ]
            )
        )
        subscribe_future.result(self.TIMEOUT)

    def on_lifecycle_connection_success(
        self,
        lifecycle_connect_success_data: mqtt5.LifecycleConnectSuccessData,
    ):
        self.future_connection_success.set_result(lifecycle_connect_success_data)

    def publish(self, publish_topic, payload):
        publish_future = self.client.publish(
            mqtt5.PublishPacket(
                topic=publish_topic,
                payload=payload,
                qos=mqtt5.QoS.AT_LEAST_ONCE,
            )
        )
        publish_completion_data = publish_future.result(self.TIMEOUT)

    def stop(self):
        self.client.stop()

import time
import json
import requests
import boto3
from mqtt import Mqtt

life = True


def get_position(timestamp, wifi_access_points):
    iotwireless = boto3.client("iotwireless")
    response = iotwireless.get_position_estimate(
        WiFiAccessPoints=wifi_access_points, Timestamp=timestamp
    )
    geoJsonPayload = json.loads(response["GeoJsonPayload"].read())
    coordinates = geoJsonPayload["coordinates"]

    longitude = coordinates[0]
    latitude = coordinates[1]

    print("latitude:{}".format(latitude))
    print("longitude:{}".format(longitude))

    url = (
        "https://nominatim.openstreetmap.org/reverse?lat={}&lon={}&format=json".format(
            coordinates[1], coordinates[0]
        )
    )
    res = json.loads(requests.get(url).text)
    print(
        "country: {} ({})".format(
            res["address"]["country"], res["address"]["country_code"]
        )
    )
    print("province: {}".format(res["address"]["province"]))
    print("region: {}".format(res["address"]["region"]))
    print("city: {}".format(res["address"]["city"]))
    print("suburb: {}".format(res["address"]["suburb"]))
    print("neighbourhood: {}".format(res["address"]["neighbourhood"]))
    print("postcode: {}".format(res["address"]["postcode"]))


def on_receive(publish_packet_data):
    publish_packet = publish_packet_data.publish_packet
    payload = json.loads(publish_packet.payload.decode())
    print("payload: {}".format(payload))

    get_position(payload["Timestamp"], payload["WiFiAccessPoints"])

    global life
    life = False


if __name__ == "__main__":
    endpoint = "xxxxxxxxxx-ats.iot.ap-northeast-1.amazonaws.com"
    port = 8883

    server_id = "server"
    client_id = "0001"
    subscribe_topic = "sensor/{}".format(client_id)
    publish_topic = "command/{}".format(client_id)

    mqtt = Mqtt(endpoint, port, server_id, subscribe_topic, on_receive)
    mqtt.publish(publish_topic, "location")

    while life:
        time.sleep(1)